home *** CD-ROM | disk | FTP | other *** search
/ Amiga Format CD 32 / Amiga Format AFCD32 (Nov 1998, Issue 117).iso / -seriously_amiga- / programming / other / cgraphx / c / include / inline / cybergraphics.h
C/C++ Source or Header  |  1998-08-10  |  14KB  |  450 lines
  1. /*
  2.  *   GCC interfaces for cybergraphics.library.
  3.  *   Use it for generating lib files or for direct inclusion.
  4.  *   Based on the output of 'FD2Inline' (12/04/95)
  5.  *
  6.  *   Reinhard Haslbeck
  7.  *   (haslbeck@informatik.tu-muenchen.de)
  8. */
  9.  
  10. #include <sys/cdefs.h>
  11. #include <inline/stubs.h>
  12.  
  13. #include <stdarg.h>
  14. #include <libraries/cybergraphics.h>
  15. __BEGIN_DECLS
  16.  
  17. #ifndef BASE_EXT_DECL
  18. #define BASE_EXT_DECL extern struct Library*  CyberGfxBase;
  19. #endif
  20. #ifndef BASE_PAR_DECL
  21. #define BASE_PAR_DECL
  22. #define BASE_PAR_DECL0 void
  23. #endif
  24. #ifndef BASE_NAME
  25. #define BASE_NAME CyberGfxBase
  26. #endif
  27.  
  28. static __inline struct List  *AllocCModeTagList( BASE_PAR_DECL struct TagItem *  ModeListTags )
  29. {
  30.         BASE_EXT_DECL
  31.         register _res __asm("d0");
  32.         register void *a6 __asm("a6");
  33.         register struct TagItem * a1 __asm("a1");
  34.  
  35.         a6 = BASE_NAME;
  36.         a1 = ModeListTags;
  37.         __asm __volatile ("jsr a6@(-0x48)"
  38.         : "=r" (_res)
  39.         : "r" (a6), "r" (a1)
  40.         : "d0", "d1", "a0", "a1" );
  41.         return (struct List *) _res;
  42. }
  43. #ifndef NO_INLINE_STDARG
  44. #define AllocCModeListTags( tags...) \
  45.   ({ struct TagItem _tags[] = { tags };  AllocCModeTagList( _tags ); })
  46. #endif /* not NO_INLINE_STDARG */
  47.  
  48. static __inline ULONG BestCModeIDTagList( BASE_PAR_DECL struct TagItem *  BestModeIDTags )
  49. {
  50.         BASE_EXT_DECL
  51.         register _res __asm("d0");
  52.         register void *a6 __asm("a6");
  53.         register struct TagItem * a0 __asm("a0");
  54.  
  55.         a6 = BASE_NAME;
  56.         a0 = BestModeIDTags;
  57.         __asm __volatile ("jsr a6@(-0x3c)"
  58.         : "=r" (_res)
  59.         : "r" (a6), "r" (a0)
  60.         : "d0", "d1", "a0", "a1" );
  61.         return _res;
  62. }
  63. #ifndef NO_INLINE_STDARG
  64. #define BestCModeIDTags( tags...) \
  65.   ({ struct TagItem _tags[] = { tags }; BestCModeIDTagList ( _tags ); })
  66. #endif /* not NO_INLINE_STDARG */
  67. static __inline ULONG CModeRequestTagList( BASE_PAR_DECL APTR  ModeRequest, struct TagItem *  ModeRequestTags )
  68. {
  69.         BASE_EXT_DECL
  70.         register _res __asm("d0");
  71.         register void *a6 __asm("a6");
  72.         register APTR a0 __asm("a0");
  73.         register struct TagItem * a1 __asm("a1");
  74.  
  75.         a6 = BASE_NAME;
  76.         a0 = ModeRequest;
  77.         a1 = ModeRequestTags;
  78.         __asm __volatile ("jsr a6@(-0x42)"
  79.         : "=r" (_res)
  80.         : "r" (a6), "r" (a0), "r" (a1)
  81.         : "d0", "d1", "a0", "a1" );
  82.         return _res;
  83. }
  84. #ifndef NO_INLINE_STDARG
  85. #define CModeRequestTags(a0, tags...) \
  86.   ({ struct TagItem _tags[] = { tags }; CModeRequestTagList ((a0), _tags); })
  87. #endif /* not NO_INLINE_STDARG */
  88.  
  89. static __inline void CVideoCtrlTagList( BASE_PAR_DECL struct ViewPort *  ViewPort, struct TagItem *  TagList )
  90. {
  91.         BASE_EXT_DECL
  92.         register void *a6 __asm("a6");
  93.         register struct ViewPort * a0 __asm("a0");
  94.         register struct TagItem * a1 __asm("a1");
  95.  
  96.         a6 = BASE_NAME;
  97.         a0 = ViewPort;
  98.         a1 = TagList;
  99.         __asm __volatile ("jsr a6@(-0xa2)"
  100.         :
  101.         : "r" (a6), "r" (a0), "r" (a1)
  102.         : "d0", "d1", "a0", "a1" );
  103. }
  104. #ifndef NO_INLINE_STDARG
  105. #define CVideoCtrlTags(a0, tags...) \
  106.   ({ struct TagItem _tags[] = { tags }; CVideoCtrlTagList ((a0), _tags); })
  107. #endif /* not NO_INLINE_STDARG */
  108.  
  109. static __inline void DoCDrawMethodTagList( BASE_PAR_DECL struct Hook *  Hook, struct RastPort *  RastPort, struct TagItem *  TagList )
  110. {
  111.         BASE_EXT_DECL
  112.         register void *a6 __asm("a6");
  113.         register struct Hook * a0 __asm("a0");
  114.         register struct RastPort * a1 __asm("a1");
  115.         register struct TagItem * a2 __asm("a2");
  116.  
  117.         a6 = BASE_NAME;
  118.         a0 = Hook;
  119.         a1 = RastPort;
  120.         a2 = TagList;
  121.         __asm __volatile ("jsr a6@(-0x9c)"
  122.         :
  123.         : "r" (a6), "r" (a0), "r" (a1), "r" (a2)
  124.         : "d0", "d1", "a0", "a1", "a2" );
  125. }
  126. #ifndef NO_INLINE_STDARG
  127. #define DoCDrawMethodTags(a0, a1, tags...) \
  128.   ({ struct TagItem _tags[] = { tags }; DoCDrawMethodTagList ((a0), (a1), _tags); })
  129. #endif /* not NO_INLINE_STDARG */
  130.  
  131. static __inline ULONG FillPixelArray( BASE_PAR_DECL struct RastPort *  RastPort, UWORD  DestX, UWORD  DestY, UWORD  SizeX, UWORD  SizeY, ULONG  ARGB )
  132. {
  133.         BASE_EXT_DECL
  134.         register _res __asm("d0");
  135.         register void *a6 __asm("a6");
  136.         register struct RastPort * a1 __asm("a1");
  137.         register UWORD d0 __asm("d0");
  138.         register UWORD d1 __asm("d1");
  139.         register UWORD d2 __asm("d2");
  140.         register UWORD d3 __asm("d3");
  141.         register ULONG d4 __asm("d4");
  142.  
  143.         a6 = BASE_NAME;
  144.         a1 = RastPort;
  145.         d0 = DestX;
  146.         d1 = DestY;
  147.         d2 = SizeX;
  148.         d3 = SizeY;
  149.         d4 = ARGB;
  150.         __asm __volatile ("jsr a6@(-0x96)"
  151.         : "=r" (_res)
  152.         : "r" (a6), "r" (a1), "r" (d0), "r" (d1), "r" (d2), "r" (d3), "r" (d4)
  153.         : "d0", "d1", "a0", "a1", "d2", "d3", "d4" );
  154.         return _res;
  155. }
  156. static __inline void FreeCModeList( BASE_PAR_DECL struct List *  ModeList )
  157. {
  158.         BASE_EXT_DECL
  159.         register void *a6 __asm("a6");
  160.         register struct List * a0 __asm("a0");
  161.  
  162.         a6 = BASE_NAME;
  163.         a0 = ModeList;
  164.         __asm __volatile ("jsr a6@(-0x4e)"
  165.         :
  166.         : "r" (a6), "r" (a0)
  167.         : "d0", "d1", "a0", "a1" );
  168. }
  169. static __inline ULONG GetCyberIDAttr( BASE_PAR_DECL ULONG  CyberIDAttr, ULONG  CyberDisplayModeID )
  170. {
  171.         BASE_EXT_DECL
  172.         register _res __asm("d0");
  173.         register void *a6 __asm("a6");
  174.         register ULONG d0 __asm("d0");
  175.         register ULONG d1 __asm("d1");
  176.  
  177.         a6 = BASE_NAME;
  178.         d0 = CyberIDAttr;
  179.         d1 = CyberDisplayModeID;
  180.         __asm __volatile ("jsr a6@(-0x66)"
  181.         : "=r" (_res)
  182.         : "r" (a6), "r" (d0), "r" (d1)
  183.         : "d0", "d1", "a0", "a1" );
  184.         return _res;
  185. }
  186. static __inline ULONG GetCyberMapAttr( BASE_PAR_DECL struct BitMap *  CyberGfxBitmap, ULONG  CyberAttrTag )
  187. {
  188.         BASE_EXT_DECL
  189.         register _res __asm("d0");
  190.         register void *a6 __asm("a6");
  191.         register struct BitMap * a0 __asm("a0");
  192.         register ULONG d0 __asm("d0");
  193.  
  194.         a6 = BASE_NAME;
  195.         a0 = CyberGfxBitmap;
  196.         d0 = CyberAttrTag;
  197.         __asm __volatile ("jsr a6@(-0x60)"
  198.         : "=r" (_res)
  199.         : "r" (a6), "r" (a0), "r" (d0)
  200.         : "d0", "d1", "a0", "a1" );
  201.         return _res;
  202. }
  203. static __inline ULONG InvertPixelArray( BASE_PAR_DECL struct RastPort *  RastPort, UWORD  DestX, UWORD  DestY, UWORD  SizeX, UWORD  SizeY )
  204. {
  205.         BASE_EXT_DECL
  206.         register _res __asm("d0");
  207.         register void *a6 __asm("a6");
  208.         register struct RastPort * a1 __asm("a1");
  209.         register UWORD d0 __asm("d0");
  210.         register UWORD d1 __asm("d1");
  211.         register UWORD d2 __asm("d2");
  212.         register UWORD d3 __asm("d3");
  213.  
  214.         a6 = BASE_NAME;
  215.         a1 = RastPort;
  216.         d0 = DestX;
  217.         d1 = DestY;
  218.         d2 = SizeX;
  219.         d3 = SizeY;
  220.         __asm __volatile ("jsr a6@(-0x90)"
  221.         : "=r" (_res)
  222.         : "r" (a6), "r" (a1), "r" (d0), "r" (d1), "r" (d2), "r" (d3)
  223.         : "d0", "d1", "a0", "a1", "d2", "d3" );
  224.         return _res;
  225. }
  226. static __inline BOOL IsCyberModeID( BASE_PAR_DECL ULONG  displayID )
  227. {
  228.         BASE_EXT_DECL
  229.         register _res __asm("d0");
  230.         register void *a6 __asm("a6");
  231.         register ULONG d0 __asm("d0");
  232.  
  233.         a6 = BASE_NAME;
  234.         d0 = displayID;
  235.         __asm __volatile ("jsr a6@(-0x36)"
  236.         : "=r" (_res)
  237.         : "r" (a6), "r" (d0)
  238.         : "d0", "d1", "a0", "a1" );
  239.         return _res;
  240. }
  241. static __inline APTR LockBitMapTagList( BASE_PAR_DECL APTR  BitMap, struct TagItem *  TagList )
  242. {
  243.         BASE_EXT_DECL
  244.         register _res __asm("d0");
  245.         register void *a6 __asm("a6");
  246.         register APTR a0 __asm("a0");
  247.         register struct TagItem * a1 __asm("a1");
  248.  
  249.         a6 = BASE_NAME;
  250.         a0 = BitMap;
  251.         a1 = TagList;
  252.         __asm __volatile ("jsr a6@(-0xa8)"
  253.         : "=r" (_res)
  254.         : "r" (a6), "r" (a0), "r" (a1)
  255.         : "d0", "d1", "a0", "a1" );
  256.         return (APTR) _res;
  257. }
  258. #ifndef NO_INLINE_STDARG
  259. #define LockBitMapTags(a0, tags...) \
  260.   ({ struct TagItem _tags[] = { tags }; LockBitMapTagList ((a0), _tags); })
  261. #endif /* not NO_INLINE_STDARG */
  262.  
  263. static __inline ULONG MovePixelArray( BASE_PAR_DECL UWORD  SrcX, UWORD  SrcY, struct RastPort *  RastPort, UWORD  DestX, UWORD  DestY, UWORD  SizeX, UWORD  SizeY )
  264. {
  265.         BASE_EXT_DECL
  266.         register _res __asm("d0");
  267.         register void *a6 __asm("a6");
  268.         register UWORD d0 __asm("d0");
  269.         register UWORD d1 __asm("d1");
  270.         register struct RastPort * a1 __asm("a1");
  271.         register UWORD d2 __asm("d2");
  272.         register UWORD d3 __asm("d3");
  273.         register UWORD d4 __asm("d4");
  274.         register UWORD d5 __asm("d5");
  275.  
  276.         a6 = BASE_NAME;
  277.         d0 = SrcX;
  278.         d1 = SrcY;
  279.         a1 = RastPort;
  280.         d2 = DestX;
  281.         d3 = DestY;
  282.         d4 = SizeX;
  283.         d5 = SizeY;
  284.         __asm __volatile ("jsr a6@(-0x84)"
  285.         : "=r" (_res)
  286.         : "r" (a6), "r" (d0), "r" (d1), "r" (a1), "r" (d2), "r" (d3), "r" (d4), "r" (d5)
  287.         : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5" );
  288.         return _res;
  289. }
  290. static __inline ULONG ReadPixelArray( BASE_PAR_DECL APTR  destRect, UWORD  destX, UWORD  destY, UWORD  destMod, struct RastPort *  RastPort, UWORD  SrcX, UWORD  SrcY, UWORD  SizeX, UWORD  SizeY, UBYTE  DestFormat )
  291. {
  292.         BASE_EXT_DECL
  293.         register _res __asm("d0");
  294.         register void *a6 __asm("a6");
  295.         register APTR a0 __asm("a0");
  296.         register UWORD d0 __asm("d0");
  297.         register UWORD d1 __asm("d1");
  298.         register UWORD d2 __asm("d2");
  299.         register struct RastPort * a1 __asm("a1");
  300.         register UWORD d3 __asm("d3");
  301.         register UWORD d4 __asm("d4");
  302.         register UWORD d5 __asm("d5");
  303.         register UWORD d6 __asm("d6");
  304.         register UBYTE d7 __asm("d7");
  305.  
  306.         a6 = BASE_NAME;
  307.         a0 = destRect;
  308.         d0 = destX;
  309.         d1 = destY;
  310.         d2 = destMod;
  311.         a1 = RastPort;
  312.         d3 = SrcX;
  313.         d4 = SrcY;
  314.         d5 = SizeX;
  315.         d6 = SizeY;
  316.         d7 = DestFormat;
  317.         __asm __volatile ("jsr a6@(-0x78)"
  318.         : "=r" (_res)
  319.         : "r" (a6), "r" (a0), "r" (d0), "r" (d1), "r" (d2), "r" (a1), "r" (d3), "r" (d4), "r" (d5), "r" (d6), "r" (d7)
  320.         : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5", "d6", "d7" );
  321.         return _res;
  322. }
  323. static __inline ULONG ReadRGBPixel( BASE_PAR_DECL struct RastPort *  RastPort, UWORD  x, UWORD  y )
  324. {
  325.         BASE_EXT_DECL
  326.         register _res __asm("d0");
  327.         register void *a6 __asm("a6");
  328.         register struct RastPort * a1 __asm("a1");
  329.         register UWORD d0 __asm("d0");
  330.         register UWORD d1 __asm("d1");
  331.  
  332.         a6 = BASE_NAME;
  333.         a1 = RastPort;
  334.         d0 = x;
  335.         d1 = y;
  336.         __asm __volatile ("jsr a6@(-0x6c)"
  337.         : "=r" (_res)
  338.         : "r" (a6), "r" (a1), "r" (d0), "r" (d1)
  339.         : "d0", "d1", "a0", "a1" );
  340.         return _res;
  341. }
  342. static __inline LONG ScalePixelArray( BASE_PAR_DECL APTR  srcRect, UWORD  SrcW, UWORD  SrcH, UWORD  SrcMod, struct RastPort *  RastPort, UWORD  DestX, UWORD  DestY, UWORD  DestW, UWORD  DestH, UBYTE  SrcFormat )
  343. {
  344.         BASE_EXT_DECL
  345.         register _res __asm("d0");
  346.         register void *a6 __asm("a6");
  347.         register APTR a0 __asm("a0");
  348.         register UWORD d0 __asm("d0");
  349.         register UWORD d1 __asm("d1");
  350.         register UWORD d2 __asm("d2");
  351.         register struct RastPort * a1 __asm("a1");
  352.         register UWORD d3 __asm("d3");
  353.         register UWORD d4 __asm("d4");
  354.         register UWORD d5 __asm("d5");
  355.         register UWORD d6 __asm("d6");
  356.         register UBYTE d7 __asm("d7");
  357.  
  358.         a6 = BASE_NAME;
  359.         a0 = srcRect;
  360.         d0 = SrcW;
  361.         d1 = SrcH;
  362.         d2 = SrcMod;
  363.         a1 = RastPort;
  364.         d3 = DestX;
  365.         d4 = DestY;
  366.         d5 = DestW;
  367.         d6 = DestH;
  368.         d7 = SrcFormat;
  369.         __asm __volatile ("jsr a6@(-0x5a)"
  370.         : "=r" (_res)
  371.         : "r" (a6), "r" (a0), "r" (d0), "r" (d1), "r" (d2), "r" (a1), "r" (d3), "r" (d4), "r" (d5), "r" (d6), "r" (d7)
  372.         : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5", "d6", "d7" );
  373.         return _res;
  374. }
  375. static __inline void UnLockBitMap( BASE_PAR_DECL APTR  Handle )
  376. {
  377.         BASE_EXT_DECL
  378.         register void *a6 __asm("a6");
  379.         register APTR a0 __asm("a0");
  380.  
  381.         a6 = BASE_NAME;
  382.         a0 = Handle;
  383.         __asm __volatile ("jsr a6@(-0xae)"
  384.         :
  385.         : "r" (a6), "r" (a0)
  386.         : "d0", "d1", "a0", "a1" );
  387. }
  388. static __inline ULONG WritePixelArray( BASE_PAR_DECL APTR  srcRect, UWORD  SrcX, UWORD  SrcY, UWORD  SrcMod, struct RastPort *  RastPort, UWORD  DestX, UWORD  DestY, UWORD  SizeX, UWORD  SizeY, UBYTE  SrcFormat )
  389. {
  390.         BASE_EXT_DECL
  391.         register _res __asm("d0");
  392.         register void *a6 __asm("a6");
  393.         register APTR a0 __asm("a0");
  394.         register UWORD d0 __asm("d0");
  395.         register UWORD d1 __asm("d1");
  396.         register UWORD d2 __asm("d2");
  397.         register struct RastPort * a1 __asm("a1");
  398.         register UWORD d3 __asm("d3");
  399.         register UWORD d4 __asm("d4");
  400.         register UWORD d5 __asm("d5");
  401.         register UWORD d6 __asm("d6");
  402.         register UBYTE d7 __asm("d7");
  403.  
  404.         a6 = BASE_NAME;
  405.         a0 = srcRect;
  406.         d0 = SrcX;
  407.         d1 = SrcY;
  408.         d2 = SrcMod;
  409.         a1 = RastPort;
  410.         d3 = DestX;
  411.         d4 = DestY;
  412.         d5 = SizeX;
  413.         d6 = SizeY;
  414.         d7 = SrcFormat;
  415.         __asm __volatile ("jsr a6@(-0x7e)"
  416.         : "=r" (_res)
  417.         : "r" (a6), "r" (a0), "r" (d0), "r" (d1), "r" (d2), "r" (a1), "r" (d3), "r" (d4), "r" (d5), "r" (d6), "r" (d7)
  418.         : "d0", "d1", "a0", "a1", "d2", "d3", "d4", "d5", "d6", "d7" );
  419.         return _res;
  420. }
  421. static __inline LONG WriteRGBPixel( BASE_PAR_DECL struct RastPort *  RastPort, UWORD  x, UWORD  y, ULONG  argb )
  422. {
  423.         BASE_EXT_DECL
  424.         register _res __asm("d0");
  425.         register void *a6 __asm("a6");
  426.         register struct RastPort * a1 __asm("a1");
  427.         register UWORD d0 __asm("d0");
  428.         register UWORD d1 __asm("d1");
  429.         register ULONG d2 __asm("d2");
  430.  
  431.         a6 = BASE_NAME;
  432.         a1 = RastPort;
  433.         d0 = x;
  434.         d1 = y;
  435.         d2 = argb;
  436.         __asm __volatile ("jsr a6@(-0x72)"
  437.         : "=r" (_res)
  438.         : "r" (a6), "r" (a1), "r" (d0), "r" (d1), "r" (d2)
  439.         : "d0", "d1", "a0", "a1", "d2" );
  440.         return _res;
  441. }
  442.  
  443. #undef BASE_EXT_DECL
  444. #undef BASE_PAR_DECL
  445. #undef BASE_PAR_DECL0
  446. #undef BASE_NAME
  447.  
  448. __END_DECLS
  449.  
  450.